# ui/main_window.py - 修复主窗口功能
import tkinter as tk
from tkinter import ttk, Menu, messagebox
import os
from pathlib import Path

from ui.components import create_main_ui, create_login_dialog
from ui.download_window import DownloadWindow
from core.auth_manager import AuthManager
from core.download_manager import DownloadManager

class MainWindow:
    """主窗口 - 负责界面布局和用户交互"""
    
    def __init__(self, root, config, note_manager):
        self.root = root
        self.config = config
        self.note_manager = note_manager
        
        # 初始化管理器
        self.auth_manager = AuthManager(config)
        self.download_manager = None  # 延迟初始化
        
        # 设置窗口
        self.setup_window()
        
        # 创建UI组件
        self.setup_ui()
        
        # 绑定事件
        self.bind_events()
        
        # 初始状态
        self.update_ui_state()
        
        # 加载本地数据
        self.load_local_data()
    
    def setup_window(self):
        """设置窗口属性"""
        self.root.title(f"{self.config.app_name} {self.config.version}")
        self.root.geometry("1000x700")
        
        # 设置图标（如果有）
        self.set_window_icon()
    
    def set_window_icon(self):
        """设置窗口图标"""
        try:
            # 尝试加载图标文件
            icon_path = Path(__file__).parent.parent / "assets" / "icon.ico"
            if icon_path.exists():
                self.root.iconbitmap(str(icon_path))
        except:
            pass  # 图标文件不存在或加载失败
    
    def setup_ui(self):
        """创建UI界面"""
        # 创建菜单栏
        self.create_menu_bar()
        
        # 创建主UI组件
        ui_components = create_main_ui(self.root)
        
        # 保存UI组件引用
        self.search_var = ui_components["search_var"]
        self.search_entry = ui_components["search_entry"]
        self.file_listbox = ui_components["file_listbox"]
        self.file_status_label = ui_components["file_status_label"]
        self.title_var = ui_components["title_var"]
        self.title_entry = ui_components["title_entry"]
        self.content_text = ui_components["content_text"]
        self.status_var = ui_components["status_var"]
        self.context_menu = ui_components["context_menu"]
        
        # 设置笔记管理器的状态回调
        self.note_manager.set_status_callback(self.update_status)
    
    def create_menu_bar(self):
        """创建菜单栏"""
        menubar = Menu(self.root)
        self.root.config(menu=menubar)
        
        # 文件菜单
        file_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="文件", menu=file_menu)
        file_menu.add_command(label="新建笔记", command=self.new_note, accelerator="Ctrl+N")
        file_menu.add_command(label="保存笔记", command=self.save_note, accelerator="Ctrl+S")
        file_menu.add_separator()
        file_menu.add_command(label="下载所有文件", command=self.download_all_files)
        file_menu.add_command(label="强制重新下载", command=self.force_redownload_all)
        file_menu.add_separator()
        file_menu.add_command(label="清除本地缓存", command=self.clear_local_cache)
        file_menu.add_separator()
        file_menu.add_command(label="退出", command=self.root.quit)
        
        # 编辑菜单
        edit_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="编辑", menu=edit_menu)
        edit_menu.add_command(label="撤销", command=self.undo, accelerator="Ctrl+Z")
        edit_menu.add_command(label="重做", command=self.redo, accelerator="Ctrl+Y")
        edit_menu.add_separator()
        edit_menu.add_command(label="剪切", command=self.cut, accelerator="Ctrl+X")
        edit_menu.add_command(label="复制", command=self.copy, accelerator="Ctrl+C")
        edit_menu.add_command(label="粘贴", command=self.paste, accelerator="Ctrl+V")
        
        # 账户菜单
        self.account_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="账户", menu=self.account_menu)
        self.update_account_menu()
        
        # 工具菜单
        tools_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="工具", menu=tools_menu)
        tools_menu.add_command(label="获取下载文件", command=self.show_download_window)
        tools_menu.add_command(label="同步文件索引", command=self.sync_files_index)
        tools_menu.add_separator()
        tools_menu.add_command(label="检查更新", command=self.check_for_updates)
        
        # 帮助菜单
        help_menu = Menu(menubar, tearoff=0)
        menubar.add_cascade(label="帮助", menu=help_menu)
        help_menu.add_command(label="关于", command=self.show_about)
        help_menu.add_command(label="使用说明", command=self.show_help)
    
    def update_account_menu(self):
        """更新账户菜单状态"""
        self.account_menu.delete(0, 'end')
        
        if self.note_manager.is_authenticated:
            self.account_menu.add_command(
                label=f"已登录: {self.config.email}", 
                state="disabled"
            )
            self.account_menu.add_separator()
            self.account_menu.add_command(label="退出登录", command=self.logout)
        else:
            self.account_menu.add_command(label="登录", command=self.show_login_dialog)
    
    def bind_events(self):
        """绑定事件处理"""
        # 搜索框事件
        self.search_var.trace('w', self.on_search_change)
        
        # 文件列表事件
        self.file_listbox.bind('<<ListboxSelect>>', self.on_file_select)
        self.file_listbox.bind("<Button-3>", self.show_context_menu)
        
        # 编辑器事件
        self.title_entry.bind('<KeyRelease>', self.on_title_change)
        self.content_text.bind('<KeyRelease>', self.on_content_change)
        
        # 键盘快捷键
        self.root.bind('<Control-n>', lambda e: self.new_note())
        self.root.bind('<Control-s>', lambda e: self.save_note())
        self.root.bind('<Control-z>', lambda e: self.undo())
        self.root.bind('<Control-y>', lambda e: self.redo())
    
    def load_local_data(self):
        """加载本地数据"""
        self.update_status("正在加载本地文件...")
        self.update_file_list()
        self.update_status("本地文件加载完成")
        
        # 检查认证状态，如果已保存凭据则自动登录
        if self.config.email and self.config.password:
            self.authenticate_and_sync()
    
    def update_ui_state(self):
        """更新UI状态"""
        if self.note_manager.is_authenticated:
            self.file_status_label.config(text="已登录")
        else:
            self.file_status_label.config(text="离线模式")
    
    def update_status(self, message):
        """更新状态栏"""
        self.status_var.set(message)
    
    def show_context_menu(self, event):
        """显示右键菜单"""
        selection = self.file_listbox.curselection()
        if selection:
            self.context_menu.post(event.x_root, event.y_root)
    
    # 文件操作相关方法
    def on_search_change(self, *args):
        """搜索框内容改变事件"""
        keyword = self.search_var.get()
        self.update_file_list(keyword)
    
    def on_file_select(self, event):
        """文件选择事件"""
        selection = self.file_listbox.curselection()
        if selection:
            index = selection[0]
            if index < len(self.file_list_map):
                filename = self.file_list_map[index]
                self.selected_file = filename
                self.load_selected_file(filename)
    
    def on_title_change(self, event):
        """标题改变事件"""
        # 可以在这里添加自动保存逻辑
        pass
    
    def on_content_change(self, event):
        """内容改变事件"""
        # 可以在这里添加自动保存逻辑
        pass
    
    def update_file_list(self, keyword=None):
        """更新文件列表"""
        self.file_listbox.delete(0, tk.END)
        self.file_list_map = []
        
        files = self.note_manager.search_files(keyword)
        for file_info in files:
            filename = file_info.get("name", "")
            title = file_info.get("title", "")
            size = file_info.get("size", 0)
            
            from utils.file_utils import format_file_size
            formatted_size = format_file_size(size)
            display_text = f"{title} ({formatted_size})"
            
            self.file_listbox.insert(tk.END, display_text)
            self.file_list_map.append(filename)
        
        self.file_status_label.config(text=f"共 {len(files)} 个文件")
    
    def load_selected_file(self, filename):
        """加载选中的文件"""
        self.update_status("正在加载文件...")
        
        def load_callback(title, content, hash_valid):
            self.root.after(0, lambda: self.update_editor(title, content, hash_valid))
            self.root.after(0, lambda: self.update_status("文件加载完成"))
        
        self.note_manager.load_file(filename, load_callback)
    
    def update_editor(self, title, content, hash_valid):
        """更新编辑器内容"""
        self.title_var.set(title)
        self.content_text.delete(1.0, tk.END)
        self.content_text.insert(1.0, content)
        
        status_text = "已验证" if hash_valid else "签名无法验证"
        if not self.note_manager.is_authenticated:
            status_text = "离线模式"
        self.file_status_label.config(text=status_text)
    
    # 笔记操作相关方法
    def new_note(self):
        """新建笔记"""
        self.title_var.set("")
        self.content_text.delete(1.0, tk.END)
        self.selected_file = None
        self.file_status_label.config(text="新建笔记")
        self.update_status("已创建新笔记")
    
    def save_note(self):
        """保存笔记"""
        title = self.title_var.get().strip()
        content = self.content_text.get(1.0, tk.END).strip()
        
        if not title:
            messagebox.showwarning("警告", "请输入标题")
            return
        
        import re
        if not re.match(r'^[\w\u4e00-\u9fa5]{1,32}$', title):
            messagebox.showwarning("警告", "标题只能包含汉字、字母、数字和下划线，且不超过32个字符")
            return
        
        if not self.note_manager.is_authenticated:
            messagebox.showinfo("提示", "请先登录")
            return
        
        def upload_thread():
            self.update_status("正在上传...")
            success = self.note_manager.upload_file(title, content)
            self.root.after(0, lambda: self.on_upload_complete(success))
        
        import threading
        threading.Thread(target=upload_thread, daemon=True).start()
    
    def on_upload_complete(self, success):
        """上传完成回调"""
        if success:
            self.update_status("上传完成")
            self.update_file_list(self.search_var.get())
        else:
            self.update_status("上传失败")
    
    def undo(self):
        """撤销操作"""
        try:
            self.content_text.edit_undo()
        except:
            pass
    
    def redo(self):
        """重做操作"""
        try:
            self.content_text.edit_redo()
        except:
            pass
    
    def cut(self):
        """剪切"""
        try:
            self.content_text.event_generate("<<Cut>>")
        except:
            pass
    
    def copy(self):
        """复制"""
        try:
            self.content_text.event_generate("<<Copy>>")
        except:
            pass
    
    def paste(self):
        """粘贴"""
        try:
            self.content_text.event_generate("<<Paste>>")
        except:
            pass
    
    # 同步和下载相关方法
    def sync_files_index(self):
        """同步文件索引"""
        if not self.note_manager.is_authenticated:
            messagebox.showinfo("提示", "请先登录")
            return
        
        def sync_thread():
            self.update_status("正在同步...")
            self.note_manager.sync_files_index(self.on_sync_complete)
        
        import threading
        threading.Thread(target=sync_thread, daemon=True).start()
    
    def on_sync_complete(self, success):
        """同步完成回调"""
        if success:
            self.update_status("同步完成")
            self.update_file_list(self.search_var.get())
        else:
            self.update_status("同步失败")
    
    def download_all_files(self):
        """下载所有文件"""
        if not self.note_manager.is_authenticated:
            messagebox.showinfo("提示", "请先登录")
            return
        
        def on_index_updated():
            self.update_status("文件索引已更新，正在后台下载文件...")
            self.update_file_list(self.search_var.get())
        
        def download_thread():
            self.update_status("正在同步文件索引...")
            self.note_manager.download_all_files(
                self.on_download_all_complete,
                on_index_updated
            )
        
        import threading
        threading.Thread(target=download_thread, daemon=True).start()
    
    def on_download_all_complete(self, success):
        """全部下载完成回调"""
        if success:
            self.update_status("全部文件已下载完成")
            self.update_file_list(self.search_var.get())
        else:
            self.update_status("下载失败，部分文件验证错误")
            self.update_file_list(self.search_var.get())
    
    def force_redownload_all(self):
        """强制重新下载所有文件"""
        if not self.note_manager.is_authenticated:
            messagebox.showinfo("提示", "请先登录")
            return
        
        if messagebox.askyesno("确认", "确定要强制重新下载所有文件吗？这将覆盖所有本地缓存。"):
            def clear_and_download():
                # 先清除缓存
                self.note_manager.clear_local_cache()
                # 然后重新下载
                self.download_all_files()
            
            import threading
            threading.Thread(target=clear_and_download, daemon=True).start()
    
    def clear_local_cache(self):
        """清除本地缓存"""
        if not self.note_manager.is_authenticated:
            messagebox.showinfo("提示", "请先登录")
            return
        
        if messagebox.askyesno("确认", "确定要清除所有本地缓存吗？这将删除所有已下载的文件，但不会影响云端数据。"):
            def clear_thread():
                self.update_status("正在清除缓存...")
                success = self.note_manager.clear_local_cache()
                self.root.after(0, lambda: self.on_clear_cache_complete(success))
            
            import threading
            threading.Thread(target=clear_thread, daemon=True).start()
    
    def on_clear_cache_complete(self, success):
        """清除缓存完成回调"""
        if success:
            self.update_status("缓存已清除")
            self.file_listbox.delete(0, tk.END)
            self.new_note()
        else:
            self.update_status("清除缓存失败")
    
    # 下载窗口相关方法
    def show_download_window(self):
        """显示下载窗口"""
        if not self.note_manager.is_authenticated:
            messagebox.showinfo("提示", "请先登录以使用下载功能")
            return
        
        # 延迟初始化下载管理器
        if self.download_manager is None:
            self.download_manager = DownloadManager(self.config, self.root)
            self.download_manager.initialize_cloud_sync()
            
            # 使用笔记管理器的认证状态
            self.download_manager.cloud_sync = self.note_manager.cloud_sync
            self.download_manager.cloud_sync.is_authenticated = self.note_manager.is_authenticated
            self.download_manager.cloud_sync.auth_header = self.note_manager.cloud_sync.auth_header
        
        # 创建下载窗口
        from ui.download_window import DownloadWindow
        download_window = DownloadWindow(
            self.root, self.config, self.download_manager, self.auth_manager
        )
        
        # 同步数据
        download_window.sync_data()
    
    # 账户相关方法
    def show_login_dialog(self):
        """显示登录对话框"""
        create_login_dialog(
            self.root, self.config, self.note_manager,
            self.update_account_menu, self.file_status_label, self.sync_files_index
        )
    
    def authenticate_and_sync(self):
        """自动认证和同步"""
        def auth_thread():
            success = self.note_manager.authenticate(
                self.config.email, self.config.password
            )
            if success:
                self.root.after(0, lambda: self.update_account_menu())
                self.root.after(0, lambda: self.update_ui_state())
                self.root.after(0, lambda: self.sync_files_index())
            else:
                self.root.after(0, lambda: self.update_account_menu())
                self.root.after(0, lambda: self.update_ui_state())
        
        import threading
        threading.Thread(target=auth_thread, daemon=True).start()
    
    def logout(self):
        """退出登录"""
        if not self.note_manager.is_authenticated:
            self.update_status("您尚未登录")
            return
        
        if messagebox.askyesno("确认", "确定要退出登录吗？"):
            self.note_manager.logout()
            self.new_note()
            self.file_listbox.delete(0, tk.END)
            self.update_ui_state()
            self.update_status("已退出登录")
            self.update_account_menu()
            self.load_local_data()
    
    # 工具方法
    def check_for_updates(self):
        """检查更新"""
        # TODO: 实现更新检查逻辑
        messagebox.showinfo("检查更新", "当前已是最新版本")
    
    def show_about(self):
        """显示关于信息"""
        about_text = f"""{self.config.app_name} v{self.config.version}

一个基于WebDAV的笔记和文件管理工具。

功能特性:
• 云端笔记同步
• 文件版本管理
• 离线访问支持
• 安全哈希验证

技术支持: 使用CloudSync库进行WebDAV同步"""
        
        messagebox.showinfo("关于", about_text)
    
    def show_help(self):
        """显示使用说明"""
        help_text = """使用说明:

基本操作:
1. 登录: 在账户菜单中登录您的WebDAV账户
2. 新建笔记: 点击文件菜单或使用Ctrl+N
3. 保存笔记: 点击文件菜单或使用Ctrl+S
4. 搜索文件: 在搜索框中输入关键词

同步功能:
• 同步文件索引: 从云端获取最新文件列表
• 下载所有文件: 将云端所有文件下载到本地缓存
• 强制重新下载: 清除缓存并重新下载所有文件

下载管理:
• 获取下载文件: 打开文件下载管理器
• 支持版本管理和文件下载

快捷键:
Ctrl+N: 新建笔记
Ctrl+S: 保存笔记
Ctrl+Z: 撤销
Ctrl+Y: 重做"""
        
        # 创建帮助窗口
        help_window = tk.Toplevel(self.root)
        help_window.title("使用说明")
        help_window.geometry("500x400")
        
        text_widget = tk.Text(help_window, wrap=tk.WORD, padx=10, pady=10)
        text_widget.insert(1.0, help_text)
        text_widget.config(state=tk.DISABLED)
        
        scrollbar = ttk.Scrollbar(help_window, orient=tk.VERTICAL, command=text_widget.yview)
        text_widget.configure(yscrollcommand=scrollbar.set)
        
        text_widget.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)